/**
 * API请求处理工具类
 */
var adndisk = {
    /**
     * 基础URL配置
     */
    baseUrl: '',

    /**
     * 初始化配置
     * @param {Object} config 配置对象
     */
    init: function(config) {
        this.baseUrl = config.baseUrl || '';
    },

    /**
     * 处理JSON请求
     * @param {string} url 请求路径
     * @param {string|null} formSelector 表单选择器
     * @param {Object|null} data 请求数据
     * @param {Function} callback 回调函数
     * @param {boolean} isPolling 是否为轮询请求
     * @param {boolean} isFirstRequest 是否为第一次请求
     */
    jsonHandler: function(url, formSelector, data, callback, isPolling, isFirstRequest) {
        var requestData = data;

        // 如果提供了表单选择器，则序列化表单数据
        if (formSelector) {
            const form = $(formSelector);
            if (form.length) {
                requestData = this.serializeFormToJson(form);
            }
        }

        // 在轮询请求中，只有第一次请求显示加载状态
        if (!isPolling || isFirstRequest) {
            this.showLoading();
        }

        $.ajax({
            url: this.baseUrl + url,
            type: 'POST',
            contentType: 'application/json',
            data: JSON.stringify(requestData),
            dataType: 'json',
            success: function(response) {
                if (!isPolling || isFirstRequest) {
                    this.hideLoading();
                }
                if (typeof callback === 'function') {
                    callback(response);
                }
            }.bind(this),
            error: function(xhr, status, error) {
                if (!isPolling || isFirstRequest) {
                    this.hideLoading();
                }
                this.handleError(xhr, status, error);
                if (typeof callback === 'function') {
                    callback({
                        code: -1,
                        msg: '请求失败：' + error
                    });
                }
            }.bind(this)
        });
    },

    /**
     * 序列化表单数据为JSON对象
     * @param {jQuery} form jQuery表单对象
     * @returns {Object} JSON对象
     */
    serializeFormToJson: function(form) {
        const formArray = form.serializeArray();
        const jsonData = {};

        console.log("formArray", formArray);

        formArray.forEach(function(item) {
            // 处理数组和对象的嵌套结构
            var keys = item.name.split(/[\[\]\.]+/).filter(Boolean);
            console.log("keys", keys);

            var current = jsonData;

            keys.forEach(function(key, index) {
                if (index === keys.length - 1) {
                    // 处理值
                    if (item.value === '') {
                        current[key] = null;
                    } else if (!isNaN(item.value) && item.value.trim() !== '') {
                        // 转换数字
                        current[key] = Number(item.value);
                    } else {
                        current[key] = item.value;
                    }
                } else {
                    // 创建嵌套结构
                    current[key] = current[key] || {};
                    current = current[key];
                }
            });
        });

        console.log("jsonData", jsonData);
        return jsonData;
    },

    /**
     * 处理文件上传
     * @param {string} url 上传地址
     * @param {FormData} formData 表单数据
     * @param {Function} callback 回调函数
     * @param {Function} progressCallback 进度回调
     */
    uploadFile: function(url, formData, callback, progressCallback) {
        $.ajax({
            url: this.baseUrl + url,
            type: 'POST',
            data: formData,
            processData: false,
            contentType: false,
            xhr: function() {
                var xhr = new window.XMLHttpRequest();
                if (typeof progressCallback === 'function') {
                    xhr.upload.addEventListener('progress', function(evt) {
                        if (evt.lengthComputable) {
                            var percentCompvare = (evt.loaded / evt.total) * 100;
                            progressCallback(percentCompvare);
                        }
                    }, false);
                }
                return xhr;
            },
            success: function(response) {
                if (typeof callback === 'function') {
                    callback(response);
                }
            },
            error: function(xhr, status, error) {
                this.handleError(xhr, status, error);
                if (typeof callback === 'function') {
                    callback({
                        code: -1,
                        msg: '上传失败：' + error
                    });
                }
            }.bind(this)
        });
    },

    /**
     * 显示加载状态
     */
    showLoading: function() {
        if (!$('#loading-overlay').length) {
            $('body').append(
                '<div id="loading-overlay">' +
                '<div class="loading-spinner">' +
                '<div class="spinner"></div>' +
                '<div class="loading-text">处理中...</div>' +
                '</div>' +
                '</div>'
            );
        }
        $('#loading-overlay').show();
    },

    /**
     * 隐藏加载状态
     */
    hideLoading: function() {
        $('#loading-overlay').hide();
    },

    /**
     * 处理错误
     * @param {Object} xhr XMLHttpRequest对象
     * @param {string} status 状态
     * @param {string} error 错误信息
     */
    handleError: function(xhr, status, error) {
        console.error('Request Error:', {
            status: status,
            error: error,
            response: xhr.responseText
        });

        var errorMessage = '请求失败';
        if (xhr.responseJSON && xhr.responseJSON.msg) {
            errorMessage = xhr.responseJSON.msg;
        } else if (error) {
            errorMessage = error;
        }

        // 显示错误提示
        this.showErrorMessage(errorMessage);
    },

    /**
     * 显示错误消息
     * @param {string} message 错误信息
     */
    showErrorMessage: function(message) {
        if (!$('#error-message').length) {
            $('body').append('<div id="error-message"></div>');
        }

        const errorElement = $('#error-message');
        errorElement.text(message)
            .fadeIn()
            .delay(3000)
            .fadeOut();
    },

    /**
     * 验证表单数据
     * @param {jQuery} form jQuery表单对象
     * @returns {boolean} 验证结果
     */
    validateForm: function(form) {
        var isValid = true;

        // 清除现有的错误提示
        form.find('.field-error').remove();

        // 验证必填字段
        form.find('[required]').each(function() {
            var field = $(this);
            if (!field.val()) {
                isValid = false;
                var errorMessage = '此字段为必填项';
                field.after('<div class="field-error">' + errorMessage + '</div>');
            }
        });

        return isValid;
    },

    // 添加轮询管理器
    taskPolling: {
        pollingTasks: {},  // 存储正在轮询的任务

        startPolling: function(taskId, callback) {
            if (this.pollingTasks[taskId]) {
                return; // 如果任务已经在轮询中，则不重复启动
            }

            this.pollingTasks[taskId] = {
                interval: null,
                status: 'polling'
            };

            const poll = (isFirstRequest = false) => {
                // 只在第一次请求时显示加载状态
                adndisk.jsonHandler('/GetTaskInfo', null, { taskID: taskId }, (response) => {
                    if (typeof callback === 'function') {
                        callback(taskId, response);
                    }

                    // 检查是否需要停止轮询
                    if (this.shouldStopPolling(response)) {
                        this.stopPolling(taskId);
                    }
                }, !isFirstRequest);  // 第一次请求不传 isPolling，后续轮询传 true
            };

            // 立即执行第一次请求，显示加载状态
            poll(true);
            // 开始定时轮询，不显示加载状态
            this.pollingTasks[taskId].interval = setInterval(() => poll(false), 1000);
        },

        stopPolling: function(taskId) {
            if (this.pollingTasks[taskId]) {
                clearInterval(this.pollingTasks[taskId].interval);
                this.pollingTasks[taskId].status = 'completed';
                delete this.pollingTasks[taskId];
            }
        },

        shouldStopPolling: function(response) {
            if (response.code !== "0") {
                return true; // 如果请求失败，停止轮询
            }

            // 检查是否完成或失败
            if (response.status === "2" || // 任务完成
                response.status === "3" || // 任务失败
                response.ErrInfo || // 有错误信息
                (response.DoneFileCunt && response.AllFileCunt &&
                    parseInt(response.DoneFileCunt) >= parseInt(response.AllFileCunt))) { // 所有文件处理完成
                return true;
            }

            return false;
        },

        stopAllPolling: function() {
            Object.keys(this.pollingTasks).forEach(taskId => {
                this.stopPolling(taskId);
            });
        }
    }
};

// 添加需要的CSS样式
$('head').append(
    '<style>' +
    '#loading-overlay {' +
    'position: fixed;' +
    'top: 0;' +
    'left: 0;' +
    'width: 100%;' +
    'height: 100%;' +
    'background: rgba(0, 0, 0, 0.5);' +
    'display: none;' +
    'z-index: 9999;' +
    '}' +

    '.loading-spinner {' +
    'position: absolute;' +
    'top: 50%;' +
    'left: 50%;' +
    'transform: translate(-50%, -50%);' +
    'text-align: center;' +
    '}' +

    '.spinner {' +
    'width: 40px;' +
    'height: 40px;' +
    'border: 4px solid #f3f3f3;' +
    'border-top: 4px solid #49cc90;' +
    'border-radius: 50%;' +
    'animation: spin 1s linear infinite;' +
    'margin: 0 auto;' +
    '}' +

    '.loading-text {' +
    'color: white;' +
    'margin-top: 10px;' +
    '}' +

    '#error-message {' +
    'position: fixed;' +
    'top: 20px;' +
    'right: 20px;' +
    'background: #ff4d4f;' +
    'color: white;' +
    'padding: 10px 20px;' +
    'border-radius: 4px;' +
    'display: none;' +
    'z-index: 9999;' +
    'box-shadow: 0 2px 8px rgba(0, 0, 0, 0.15);' +
    '}' +

    '@keyframes spin {' +
    '0% { transform: rotate(0deg); }' +
    '100% { transform: rotate(360deg); }' +
    '}' +
    '</style>'
);

/**
 * 处理文件加密及信息嵌入
 * @param {Object} data 请求数据
 * @returns {Promise} 处理结果
 */
function handleSetPrintInfo(data) {
    return new Promise(function(resolve) {
        try {
            // 验证参数
            if (!Array.isArray(data.files) || !data.files.length) {
                throw new Error('文件列表不能为空');
            }

            // 验证必要的属性
            var requiredProps = ['discJson', 'outConfpath', 'taskID'];
            for (var i = 0; i < requiredProps.length; i++) {
                var prop = requiredProps[i];
                if (!data[prop]) {
                    throw new Error('缺少必要参数: ' + prop);
                }
            }

            // 验证属性长度限制
            var attributes = {
                level: data.files[0].sl,
                orgID: data.discJson.orgID,
                discID: data.discJson.discID,
                username: data.discJson.username,
                fileID: data.files[0].FID,
                discLevel: data.discJson.level
            };

            var attributesLength = JSON.stringify(attributes).length;
            if (attributesLength > 128) {
                throw new Error('属性总长度超过128字节限制');
            }

            // 生成随机加密口令
            var password = generateRandomPassword();

            // 生成配置文件
            var configData = {
                SN2: generateSN2(),
                SN: generateSN(),
                DevLevel: data.discJson.level,
                Encrypt: 1,
                DiskID: data.discJson.discID,
                orgID: data.discJson.orgID,
                username: data.discJson.username,
                timestamp: new Date().toISOString()
            };

            generateConfigFile(data.outConfpath, configData)
                .then(function() {
                    // 处理每个文件
                    var processPromises = [];
                    for (var i = 0; i < data.files.length; i++) {
                        processPromises.push(processFile(data.files[i], data.discJson, password));
                    }

                    return Promise.all(processPromises);
                })
                .then(function() {
                    resolve({
                        code: 0,
                        msg: '成功',
                        password: password
                    });
                })
                .catch(function(error) {
                    throw error;
                });

        } catch (error) {
            console.error('SetPrintInfo处理失败:', error);
            resolve({
                code: -1,
                msg: error.message || '处理失败'
            });
        }
    });
}

/**
 * 生成随机加密口令
 * @returns {string} 随机口令
 */
function generateRandomPassword() {
    var chars = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
    var password = '';
    for (var i = 0; i < 10; i++) {
        password += chars.charAt(Math.floor(Math.random() * chars.length));
    }
    return password;
}

/**
 * 生成配置文件
 * @param {string} filePath 配置文件路径
 * @param {Object} data 配置数据
 */
function generateConfigFile(filePath, data) {
    return new Promise(function(resolve) {
        var config = [
            '[autorun]',
            'open=运行本程序浏览光盘.exe',
            'icon=SecCDBrowser.ico',
            'SN2=' + data.SN2,
            'SN=' + data.SN,
            'DevLevel=' + data.DevLevel,
            'Encrypt=1',
            'DiskID=' + data.DiskID,
            'orgID=' + data.orgID,
            'username=' + data.username,
            'timestamp=' + data.timestamp
        ].join('\n');

        // 写入配置文件的逻辑
        // 这里需要根据实际情况实现文件写入
        resolve();
    });
}

/**
 * 处理单个文件的加密和信息嵌入
 * @param {Object} file 文件信息
 * @param {Object} discInfo 载体信息
 * @param {string} password 加密口令
 */
function processFile(file, discInfo, password) {
    return new Promise(function(resolve) {
        // 实现文件加密和信息嵌入的逻辑
        // 这里需要根据实际情况实现
        resolve();
    });
}
